'use strict';

const BaseController = require('./base');
const serviceName = 'cart';
const { Op } = require('sequelize');
class CartController extends BaseController {
  constructor(ctx) {
    super(ctx, serviceName);
  }
  async settle() {
    const { ctx } = this;
    const { userId, ids } = ctx.request.body;
    if (!userId) {
      return ctx.error(400, '用户ID不能为空');
    }
    const cartItems = await ctx.model.Cart.findAll({
      where: {
        id: {
          [Op.in]: ids
        },
        member_user_id: userId,
      },
      include: [
        {
          model: ctx.model.ProductItem,
          as: 'productItem',
        },
        {
          model: ctx.model.Product,
          as: 'product',
        }
      ],
    });
    ctx.success(cartItems);
  }
  /**
   * 添加商品到购物车
   * @returns {Promise<void>}
   */
  async create() {
    const { ctx } = this;
    const { product_id, product_item_id, quantity = 1, userId } = ctx.request.body;
    if (!userId) {
      return ctx.error(400, '用户ID不能为空');
    }
    if (!product_id) {
      return ctx.error(400, '商品ID不能为空');
    }
    if (!product_item_id) {
      return ctx.error(400, '商品规格ID不能为空');
    }

    // 检查商品是否存在
    const product = await ctx.model.Product.findByPk(product_id);
    if (!product) {
      return ctx.error(404, '商品不存在');
    }

    if (product.status !== 1) {
      return ctx.error(400, '商品已下架');
    }
    let productItem = await ctx.model.ProductItem.findByPk(product_item_id);
    if (!productItem) {
      return ctx.error(404, '商品规格不存在');
    }

    if (productItem.status !== 1) {
      return ctx.error(400, '商品规格已下架');
    }
    if (productItem.stock <= 0) {
      return ctx.error(400, '商品规格库存不足');
    }
    // 检查购物车中是否已存在该商品
    const existingCartItem = await ctx.model.Cart.findOne({
      where: {
        member_user_id: userId,
        product_id,
        product_item_id
      },
    });
    if (existingCartItem) {
      // 如果已存在，则更新数量
      const newQuantity = existingCartItem.quantity + Number(quantity);

      // 检查库存是否足够
      if (productItem && newQuantity > productItem.stock) {
        return ctx.error(400, '商品规格库存不足');
      } else if (!productItem && newQuantity > product.stock) {
        return ctx.error(400, '商品库存不足');
      }

      await existingCartItem.update({
        quantity: newQuantity,
        update_time: new Date(),
      });

      ctx.success(existingCartItem);
    } else {
      const cartItem = await ctx.model.Cart.create({
        type: product.type,
        member_user_id: userId,
        product_id,
        product_item_id: product_item_id || null,
        quantity,
        selected: 1,
        create_time: new Date(),
        update_time: new Date(),
      });

      ctx.success(cartItem);
    }
  }

  /**
   * 更新购物车商品数量
   * @returns {Promise<void>}
   */
  async updateNum() {
    const { ctx } = this;
    const { id, quantity } = ctx.request.body;

    if (!id) {
      return ctx.error(400, '购物车项ID不能为空');
    }

    if (!quantity || quantity <= 0) {
      return ctx.error(400, '商品数量必须大于0');
    }

    const cartItem = await ctx.model.Cart.findOne({
      where: {
        id,
      },
      include: [
        {
          model: ctx.model.Product,
          as: 'product',
        },
        {
          model: ctx.model.ProductItem,
          as: 'productItem',
        },
      ],
    });

    if (!cartItem) {
      return ctx.error(404, '购物车项不存在');
    }

    // 检查库存是否足够
    if (cartItem.productItem && quantity > cartItem.productItem.stock) {
      return ctx.error(400, '商品库存不足');
    }

    await cartItem.update({
      quantity: parseInt(quantity),
      update_time: new Date(),
    });

    ctx.success(cartItem);
  }

  /**
   * 更新购物车商品选中状态
   * @returns {Promise<void>}
   */
  async updateSelected() {
    const { ctx } = this;
    let { id, selected, userId } = ctx.request.body;
    selected = Number(selected)
    if (!id) {
      return ctx.error(400, '购物车项ID不能为空');
    }

    if (selected !== 0 && selected !== 1) {
      return ctx.error(400, '选中状态参数错误');
    }

    const cartItem = await ctx.model.Cart.findOne({
      where: {
        id,
        member_user_id: userId,
      },
    });

    if (!cartItem) {
      return ctx.error(404, '购物车项不存在');
    }

    await cartItem.update({
      selected,
      update_time: new Date(),
    });

    ctx.success(cartItem);
  }

  /**
   * 批量更新购物车商品选中状态
   * @returns {Promise<void>}
   */
  async updateAllSelected() {
    const { ctx } = this;
    let { selected, userId } = ctx.request.body;
    selected = Number(selected)
    if (selected !== 0 && selected !== 1) {
      return ctx.error(400, '选中状态参数错误');
    }

    await ctx.model.Cart.update(
      {
        selected,
        update_time: new Date(),
      },
      {
        where: {
          member_user_id: userId,
        },
      }
    );

    ctx.success({ success: true });
  }
  async deleteAll() {
    const { ctx } = this;
    let { ids } = ctx.request.body;
    if (ids.length === 0) {
      this.ctx.success({ success: true });
    }
    await ctx.model.Cart.destroy({
      where: {
        id: {
          [Op.in]: ids
        }
      },
    });
    ctx.success({ success: true });
  }
  /**
   * 删除购物车商品
   * @returns {Promise<void>}
   */
  async destroy() {
    const { ctx } = this;
    const id = ctx.params.id;

    const cartItem = await ctx.model.Cart.findOne({
      where: {
        id,
      },
    });

    if (!cartItem) {
      return ctx.error(404, '购物车项不存在');
    }

    await cartItem.destroy();

    ctx.success({ success: true });
  }

  /**
   * 清空购物车
   * @returns {Promise<void>}
   */
  async clear() {
    const { ctx } = this;
    const userId = ctx.request.body.userId

    await ctx.model.Cart.destroy({
      where: {
        member_user_id: userId,
      },
    });

    ctx.success({ success: true });
  }

  /**
   * 获取购物车商品数量
   * @returns {Promise<void>}
   */
  async count() {
    const { ctx } = this;
    const userId = ctx.query.userId

    const count = await ctx.model.Cart.count({
      where: {
        member_user_id: userId,
      },
    });

    ctx.success({ count });
  }
}

module.exports = CartController;
